home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / scope / 176-200 / scopedisk191 / lightpen / lp.c < prev    next >
C/C++ Source or Header  |  1995-03-19  |  8KB  |  256 lines
  1. /*************************************************
  2. *       Name :       lightpen
  3. * This code installs a lightpendriver as an
  4. * InputEvent-Handler.
  5. * Left  Mousebutton on Pin 3
  6. * Right Mousebutton on Pin 4
  7. *
  8. * For SAS/C compile with -v
  9. * (no stack checking)
  10. *
  11. *    © Copyright by Andreas Klingler 1988,1991
  12. *
  13. * This program is freely distributable but is NOT public domain.
  14. * It MAY NOT be included in any commercial package, or sold for
  15. * ANY amount, without written permission from the author.
  16. * However if may be included on any freely distributable package,
  17. * including packages for which a nominal copying fee of no more than
  18. * $5 is charged, as long as this copyright notice keeps intact.
  19. * This software is distributed as-is, without any warranty.
  20. *
  21. *          created 31.10.88 akk
  22. *          cleanup 27.01.91 akk
  23. *************************************************/
  24. #include <exec/types.h>
  25. #include "intuition/intuition.h"
  26. #include <exec/ports.h>
  27. #include <exec/io.h>
  28. #include <exec/memory.h>
  29. #include <devices/input.h>
  30. #include <exec/devices.h>
  31. #include <devices/inputevent.h>
  32. #include "stdio.h"
  33. #include "stdlib.h"
  34. #include "graphics/gfxbase.h"
  35. #include "graphics/view.h"
  36. #include "proto/dos.h"
  37. #include "proto/exec.h"
  38. #include "proto/intuition.h"
  39. #include "proto/graphics.h"
  40. #include "hardware/custom.h"
  41.  
  42. /***************** CONSTANTS ********************/
  43. #define LP_ENABLE 0x08
  44. #define XCOMPENSATE 42 /* This is to compensate some timing problems.
  45.               You might need to change this. Uh! Again the
  46.               answer is 42! What was the question!? */
  47.  
  48. #define BANNER "\x9B\x30;33mLightpenhandler Version 1.1\x9B\x30m © by Andreas Klingler 1988,1991\n"
  49. #define ACTIVATED " Handler installed\n"
  50. #define TERMINATING " Handler removed\n"
  51. #define PORTNAME "lightpen_AKK.port"
  52.  
  53. /****************** GLOBAL VARIABLES ************/
  54. extern struct Custom __far custom;
  55.  
  56. struct MsgPort *inputDevPort;
  57. struct IOStdReq *inputRequestBlock;
  58. struct Interrupt handlerStuff;
  59. struct OURMSG {
  60.     struct Message msgpart;
  61.     short dummy;
  62.     } msg;
  63.  
  64. struct LpInfo { short *ViewX, *ViewY;  } handlerdata;
  65.  
  66. /* Prototypes for functions defined in lp.c */
  67. struct InputEvent * __regargs __saveds myhandler(struct InputEvent *,
  68.                                                  struct LpInfo *);
  69. void main(void);
  70. void chkabort(void);
  71.  
  72.  
  73. /* Declarations for CBACK */
  74. extern BPTR _Backstdout;         /* standard output when run in background */
  75. long _BackGroundIO = 1;          /* Flag to tell it we want to do I/O      */
  76. long _stack = 4000;              /* Amount of stack space our task needs   */
  77. char *_procname = "Lightpenhandler";  /* The name of the task to create    */
  78. long _priority = 20;             /* The priority to run us at              */
  79.  
  80. /******************* Here goes the Handler ****************/
  81. struct InputEvent *
  82. __regargs __saveds myhandler(ev, mydata)
  83.     struct InputEvent *ev;  /* and a pointer to a list of events */
  84.     struct LpInfo *mydata;  /* system will pass me a pointer to my 
  85.                       own data space. */
  86.         
  87. { 
  88.     static struct InputEvent lpev; 
  89.     struct InputEvent *retwert;
  90.     BOOL lpen_invalid = FALSE,button_pressed = FALSE;
  91.     static BOOL left_down,right_down;
  92.     ULONG pos;
  93.     static ULONG *lpen = (ULONG *)&custom.vposr;
  94.     register short x,y;
  95.  
  96.     pos = *lpen;    /* read pen position (we read two
  97.                registers here: VPOSR,VHPOSR) */
  98.  
  99.     Forbid();
  100.       if ((pos != *lpen) || /* Test, if Lpen has been
  101.                    triggered since VBLANK */
  102.          ((pos & 0x1ffff) > 0x12a00)) {  retwert=ev; lpen_invalid=TRUE; }
  103.        else retwert = &lpev;
  104.  
  105.     /* Translate in HIRES INLACE coordinates (depending of position of
  106.        the View). That`s what mouse coordinates are in.
  107.        Since we have only 8 bits for the horizonal position it gets
  108.        a little bit tricky (there are 640 pixel in one line in hires!) */
  109.       x = (short)((pos <<1) & 0x1ff);
  110.       if (x < 100) x += 454;
  111.        y = ((short) (pos >> 8) &0x1ff) - *(mydata->ViewY);
  112.        x -= (*(mydata->ViewX) + XCOMPENSATE);
  113.  
  114.       lpev.ie_NextEvent = ev;  /* link lpen ahead of event stream */
  115.       lpev.ie_Class = IECLASS_POINTERPOS;
  116.       lpev.ie_Code = IECODE_NOBUTTON;
  117.       lpev.ie_Qualifier = 0;
  118.       lpev.ie_TimeStamp.tv_secs = 0;
  119.       lpev.ie_TimeStamp.tv_micro = 0;
  120.       lpev.ie_X = x << 1;
  121.       lpev.ie_Y = y << 1;
  122.  
  123.     /* Button on lightpen pressed ? */
  124.       if (right_down) {
  125.           if (!(custom.joy1dat & 1)) { lpev.ie_Code = IECODE_RBUTTON |
  126.                                   IECODE_UP_PREFIX;
  127.                            right_down = FALSE;
  128.                          button_pressed = TRUE;
  129.                        }
  130.                 }
  131.       else if (custom.joy1dat & 1) { lpev.ie_Code = IECODE_RBUTTON;
  132.                          right_down = TRUE;
  133.                      button_pressed = TRUE;
  134.                     }
  135.       if (left_down) {
  136.               if (!(custom.joy1dat & 0x100)){
  137.                     lpev.ie_Code = IECODE_LBUTTON |
  138.                                IECODE_UP_PREFIX;
  139.                     left_down = FALSE;
  140.                     button_pressed = TRUE;
  141.                     }
  142.                 }
  143.         else    if (custom.joy1dat & 0x100) {
  144.                     lpev.ie_Code = IECODE_LBUTTON;
  145.                     left_down = TRUE;
  146.                     button_pressed = TRUE;
  147.                     }
  148.  
  149.     /* Append positiondata only if it is valid */
  150.       if (button_pressed && lpen_invalid) {
  151.             lpev.ie_Class = IECLASS_RAWMOUSE;
  152.             lpev.ie_Qualifier = IEQUALIFIER_RELATIVEMOUSE;
  153.             lpev.ie_X = lpev.ie_Y = 0; 
  154.             retwert = &lpev;
  155.             }
  156.     Permit();
  157.     return (retwert);
  158. }
  159.  
  160.  
  161. void main()
  162. {
  163.     struct MsgPort *port;
  164.     SHORT error;
  165.  
  166.  
  167.     if (_Backstdout) Write(_Backstdout, BANNER, sizeof(BANNER));
  168.  
  169.     /* now see if we are allready installed */
  170.       if (!(port = FindPort(PORTNAME)))  {
  171.         /* if not, install ourself : */
  172.     if ((port = CreatePort(PORTNAME,0)) == NULL) _exit (19);
  173.  
  174.     GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",0);
  175.     if (!GfxBase) _exit(20);
  176.     
  177.     IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0);
  178.     if (!IntuitionBase) _exit(21);
  179.             
  180.     /* Tell the OS about the lightpen and enable the hardware */
  181.     GfxBase->system_bplcon0 |= LP_ENABLE;
  182.     RemakeDisplay();
  183.  
  184.     /* Determine position of the View. Attention: if someone pokes
  185.        around with Preferences while we are running, we can`t handle
  186.        this! */           
  187.     handlerdata.ViewX = (short *)&(GfxBase->ActiView->DxOffset);
  188.     handlerdata.ViewY = (short *)&(GfxBase->ActiView->DyOffset);
  189.  
  190.     inputDevPort = CreatePort(0,0);        /* for input device */
  191.     if(inputDevPort == NULL) _exit(1);    /* error during createport */
  192.     inputRequestBlock=CreateStdIO(inputDevPort);
  193.     if(inputRequestBlock == 0) { DeletePort(inputDevPort); _exit(2); }
  194.                     /* error during createstdio */
  195.  
  196.  
  197.     handlerStuff.is_Data = (APTR)&handlerdata;
  198.             /* address of its data area */
  199.     handlerStuff.is_Code = (void *)myhandler;
  200.             /* address of entry point to handler */
  201.     handlerStuff.is_Node.ln_Pri = 51;
  202.             /* set the priority one step higher than
  203.               * Intuition, so that our handler enters
  204.              * the chain ahead of Intuition.
  205.              */
  206.     error = OpenDevice("input.device",0,(struct IORequest *)inputRequestBlock,0);
  207.     if(error) _exit(23);
  208.  
  209.     inputRequestBlock->io_Command = IND_ADDHANDLER;
  210.     inputRequestBlock->io_Data = (APTR)&handlerStuff;
  211.         
  212.     DoIO((struct IORequest *)inputRequestBlock);  /* Activate the Handler */
  213.     
  214.     /* The Handler is running. Close everything we don`t need
  215.        anymore and wait until it is time to uninstall the handler.
  216.        All the dirty work is done by the handler */
  217.  
  218.     CloseLibrary((struct Library *)IntuitionBase);
  219.     CloseLibrary((struct Library *)GfxBase);
  220.  
  221.     if (_Backstdout) { Write(_Backstdout,ACTIVATED, sizeof(ACTIVATED));
  222.                Close(_Backstdout);
  223.                }
  224.     WaitPort(port);          /* Wait until we get message */
  225.     GetMsg(port);            /* to exit, then remove it */
  226.                     /* and get out           */
  227.  
  228.     inputRequestBlock->io_Command = IND_REMHANDLER;
  229.     inputRequestBlock->io_Data = (APTR)&handlerStuff;
  230.     DoIO((struct IORequest *)inputRequestBlock);
  231.  
  232.     /* close the input device */
  233.     CloseDevice((struct IORequest *)inputRequestBlock);
  234.  
  235.     /* delete the IO request */
  236.     DeleteStdIO(inputRequestBlock);
  237.  
  238.     /* free other system stuff */
  239.     DeletePort(inputDevPort);
  240.     DeletePort(port);
  241.       }   /* this is the end of the BIG-IF (and of the program */
  242.  
  243.       else  /* in this case the handler is already installed, so we
  244.            send a message to it to make it deinstall itself */
  245.     {
  246.     msg.msgpart.mn_Length = sizeof(struct OURMSG);
  247.     PutMsg(port,(struct Message *)&msg);
  248.     if (_Backstdout) { Write(_Backstdout, TERMINATING, sizeof(TERMINATING));
  249.                Close(_Backstdout);
  250.                }
  251.        }
  252. }                    /* end of main */
  253.  
  254. void MemCleanup() {}    /* We don`t want this out of lc.lib */
  255.  
  256. void chkabort() {}